module Restauracja where
 

 
import IO
 
import Data.Time
 
import Data.List
 
import Data.Char
 
import Locale
 

 

 
{-
 
SPOP projekt - Restauracja, 16.01.2011
 
Mateusz Boryn
 
Mateusz Pruchniak
 

 
-}
 

 
-----------------------------------------------
 
---------- Struktury danych
 
-----------------------------------------------
 

 
-- dane o stolikach
 
data Stolik = Stolik {
 
        stolikId             :: Int,    -- id stolika
 
        liczbaMiejsc    :: Int                  -- liczba miejsc
 
} deriving (Show, Read, Eq)
 

 
-- dane o rezerwacjach
 
data Rezerwacja = Rezerwacja {
 
        rezerwacjaId            :: Int,         -- id kolejnej rezerwacji
 
        fkstolikId              :: Int,         -- klucz obcy stolika
 
        imie                    :: String,      -- imie klienta rezerwujacego stolik    
 
        nazwisko                :: String,      -- nazwisko klienta rezerwujacego stolik
 
        numerTel                :: String,      -- numer telefonu klienta
 
        dataRezerwacji          :: Day,         -- dzien na ktory ma byc rezerwacja
 
        godzinaRezerwacji       :: Int,         -- godzina od ktorej ma byc rezerwacja
 
        dlugoscRezerwacji       :: Int,         -- czas trwania rezerwacji, w pe³nych godzinach
 
        uwagi                   :: String       -- uwagi do rezerwacji
 
} deriving (Show, Read, Eq)
 

 

 
-- zamien liste stolikow na napis, ktory mozna wypisac na ekranie
 
stoliki2String :: [Stolik] -> String
 
stoliki2String [] = ""
 
stoliki2String (stolik:resztaStolikow) = (stolik2String stolik) ++ stoliki2String resztaStolikow
 

 
-- zamien stolik na napis, ktory mozna wyisac na ekranie
 
stolik2String  :: Stolik -> String
 
stolik2String (Stolik {stolikId=stolikId, liczbaMiejsc=liczbaMiejsc}) = 
 
                "Stolik " ++ show stolikId ++ "; liczba miejsc: " ++ show liczbaMiejsc ++ "\n"
 

 
-- zastap stolik o takim samym ID
 
zastapStolik :: [Stolik] -> Stolik -> [Stolik]
 
zastapStolik [] (Stolik {stolikId=stolikId, liczbaMiejsc=liczbaMiejsc}) = [] 
 
zastapStolik [staryStolik] nowyStolik = 
 
        if (getStolikID staryStolik) == (getStolikID nowyStolik) then [nowyStolik]
 
                else [staryStolik]
 

 
zastapStolik (s:reszta) nowyStolik = (zastapStolik [s] nowyStolik) ++ (zastapStolik reszta nowyStolik)
 

 
-- usun stolik o podanym ID stolika z listy
 
usunStolikZListy :: [Stolik] -> Int -> [Stolik]
 
usunStolikZListy [] id = []
 
usunStolikZListy [stolik] id =
 
        if (getStolikID stolik) == id then
 
                []
 
        else
 
                [stolik]
 
usunStolikZListy (s:reszta) id = (usunStolikZListy [s] id) ++ (usunStolikZListy reszta id)
 

 
-- pobierz ID stolika
 
getStolikID :: Stolik -> Int
 
getStolikID (Stolik {stolikId=id}) = id
 
        
 
-- pobierz stolik na podstawie podanego ID
 
znajdzStolikID :: [Stolik] -> Int -> [Stolik]
 
znajdzStolikID [] _ = []
 
znajdzStolikID (x:xs) id =
 
        if getStolikID x == id then
 
        [x]
 
        else
 
        znajdzStolikID xs id
 
        
 

 
-- wczytaj stoliki z pliku i zwroc liste stolikow
 
wczytajStoliki = do
 
        hFile <- openFile stolikiNazwaPliku ReadMode
 
        fileStr <- hGetContents hFile
 
        let stoliki = (read fileStr) :: [Stolik]
 
        putStrLn ("Wczytano stolikow: " ++ (show (length stoliki)))
 
        hClose hFile
 
        return stoliki
 

 
-- zapisz stoliki do pliku
 
zapiszStoliki stoliki = do
 
        writeFile stolikiNazwaPliku (show stoliki)
 

 

 
-- zapisz rezerwacje do pliku
 
zapiszRezerwacje rezerwacje = do
 
        writeFile rezerwacjeNazwaPliku (show rezerwacje)
 

 
-- zamien liste rezerwacji na napis, ktory mozna wyisac na ekranie
 
rezerwacje2String :: [Rezerwacja] -> [Stolik] -> String
 
rezerwacje2String [] s = ""
 
rezerwacje2String (x:xs) s = (rezerwacja2String x s) ++ rezerwacje2String xs s
 

 
-- zamien rezerwacje na napis, ktory mozna wypisac na ekranie
 
rezerwacja2String  :: Rezerwacja -> [Stolik] -> String
 
rezerwacja2String (Rezerwacja {
 
        rezerwacjaId=rezerwacjaId, 
 
        fkstolikId=fkstolikId, 
 
        imie=imie, 
 
        nazwisko=nazwisko, 
 
        numerTel=numerTel, 
 
        dataRezerwacji=dataRezerwacji, 
 
        godzinaRezerwacji=godzinaRezerwacji,
 
        dlugoscRezerwacji=dlugoscRezerwacji, 
 
        uwagi=uwagi}) s = 
 
        "Rezerwacja " ++ show rezerwacjaId ++ "\n" 
 
                ++ "    Dzien: " ++ (show dataRezerwacji) ++ " Od: " ++ (show godzinaRezerwacji) ++ ":00 do: " ++ (show (godzinaRezerwacji + dlugoscRezerwacji)) ++ ":00 \n"
 
                ++ "    " ++ (stoliki2String (znajdzStolikID s fkstolikId) )
 
                ++ "    Imie: " ++ imie ++ " Nazwisko: " ++ nazwisko ++ " Nr tel.: " ++ numerTel ++ "\n"
 
                ++ "    Uwagi: " ++ uwagi ++ "\n"
 

 
-- wypisz rezerwacje na ekran
 
wypiszRezerwacje rezerwacje = do
 
        plikStoliki <- readFile stolikiNazwaPliku
 
        let
 
                stolikiDB = (read plikStoliki) :: [Stolik]
 
        putStrLn (rezerwacje2String rezerwacje stolikiDB)
 
        
 

 
-- wyszukaj rezerwacje na podstawie danego ID
 
znajdzRezerwacjeID :: [Rezerwacja] -> Int -> [Rezerwacja]
 
znajdzRezerwacjeID [] _ = []
 
znajdzRezerwacjeID (x:xs) id =
 
        if getRezerwacjaID x == id then
 
        [x]
 
        else
 
        znajdzRezerwacjeID xs id
 

 
-- Zwraca id rezerwacji
 
getRezerwacjaID :: Rezerwacja -> Int
 
getRezerwacjaID (Rezerwacja {rezerwacjaId=id}) = id
 

 

 

 
-- Zwraca nowe, wolne ID rezerwacji
 
getNastRezerID :: [Rezerwacja] -> Int -> Int
 
getNastRezerID [] newID = newID
 
getNastRezerID (x:xs) newID =
 
        if (getRezerwacjaID x >= newID) then
 
                getNastRezerID xs ((getRezerwacjaID x)+1)
 
        else
 
                getNastRezerID xs newID
 
                
 
-- Zwraca nowe, wolne ID rezerwacji
 
getNastStolikID :: [Stolik] -> Int -> Int
 
getNastStolikID [] newID = newID
 
getNastStolikID (x:xs) newID =
 
        if (getStolikID x >= newID) then
 
                getNastStolikID xs ((getStolikID x)+1)
 
        else
 
                getNastStolikID xs newID
 
        
 
-- wczytaj liste rezerwacji z pliku
 
wczytajRezerwacje = do
 
        hFile <- openFile rezerwacjeNazwaPliku ReadMode
 
        fileStr <- hGetContents hFile
 
        let rezerwacje = (read fileStr) :: [Rezerwacja]
 
        putStrLn ("Wczytano rezerwacji: " ++ (show (length rezerwacje)))
 
        hClose hFile
 
        return rezerwacje
 

 
-- sprawdzanie, czy string moze byc zamieniony na liczbe calkowita nieujemna
 
sprawdzCzyToLiczba :: String -> Bool
 
sprawdzCzyToLiczba "" = False
 
sprawdzCzyToLiczba [x] =
 
        if isDigit x == True then
 
        True
 
        else
 
        False
 
sprawdzCzyToLiczba (x:xs) = 
 
        if (isDigit x == True) then
 
        sprawdzCzyToLiczba xs
 
        else
 
        False
 

 
-- sprawdza, czy napis jest data w formacie YYYY-MM-DD
 
sprawdzDate :: String -> Bool
 
sprawdzDate "" = False
 
sprawdzDate date = 
 
        if ((length date) /= 10) then
 
        False
 
        else
 
        sprawdzDateString date (length date)
 
        
 
-- sprawdz, czy data wpisana z klawiatury jako string ma dobry format
 
sprawdzDateString :: String -> Int -> Bool
 
sprawdzDateString [x] 1
 
        | isDigit x == True = True
 
        | otherwise = False
 
sprawdzDateString (x:xs) ind
 
        | (ind == 3 || ind == 6) && (x == '-') = sprawdzDateString xs (ind-1)
 
        | (ind == 3 || ind == 6) && (x /= '-') = False
 
        | isDigit x == True = sprawdzDateString xs (ind-1)
 
        | otherwise = False
 

 

 

 
-- Funkcja zmieniajaca wszystkie znaki w stringu na male litery
 
stringToLower :: String -> String
 
stringToLower = map toLower
 

 
-- Zwraca nazwisko klienta z rezerwacji
 
podajNazwisko :: Rezerwacja -> String
 
podajNazwisko (Rezerwacja {nazwisko=name})= name
 

 
-- Wyszukuje wolne stoliki w danym dniu o danej godzinie na dany czas
 
znajdzWolneStoliki :: [Stolik] -> [Rezerwacja] -> Day -> Int -> Int -> [Stolik]
 
znajdzWolneStoliki stoliki rezerwacje dzien godzina dlugosc = [s | s <- stoliki, czyStolikWolny s rezerwacje dzien godzina dlugosc]
 

 

 
-- sprawdza, czy stolik jest wolny o podanej porze
 
czyStolikWolny :: Stolik -> [Rezerwacja] -> Day -> Int -> Int -> Bool
 
czyStolikWolny stolik rezerwacje dzien godzina dlugosc = not (foldr (||) False (map (\r -> czyStolikZarezerwowany r dzien godzina dlugosc (getStolikID stolik) ) rezerwacje))
 

 

 
-- sprawdza, czy dana rezerwacja zachodzi na zadany czas (dzien, godzina, dlugosc) dla zadanego stolika (stolikID)
 
czyStolikZarezerwowany :: Rezerwacja -> Day -> Int -> Int -> Int -> Bool
 
czyStolikZarezerwowany (Rezerwacja {
 
        rezerwacjaId=rezerwacjaId, 
 
        fkstolikId=fkstolikId, 
 
        imie=klientImie,
 
        nazwisko=klientNazwisko,
 
        numerTel=klientNrTel,
 
        dataRezerwacji=dataRezerwacji, 
 
        godzinaRezerwacji=godzinaRezerwacji,
 
        dlugoscRezerwacji=dlugoscRezerwacji, 
 
        uwagi=uwagi}) dzienNowa godzinaNowa dlugoscNowa stolikID= 
 
        fkstolikId == stolikID && dataRezerwacji == dzienNowa && 
 
        (
 
                (godzinaRezerwacji <= godzinaNowa && godzinaNowa < godzinaRezerwacji + dlugoscRezerwacji) ||
 
                (godzinaNowa <= godzinaRezerwacji && godzinaRezerwacji < godzinaNowa + dlugoscNowa) 
 
        )
 

 

 

 
-- Plik z danymi o stolikach
 
stolikiNazwaPliku = "stoliki.txt"
 
-- Plik z danymi o rezerwacjach
 
rezerwacjeNazwaPliku = "rezerwacje.txt"
 

 
-- godziny pracy restauracji -- poza tymi godzinami nie mozna dodawac rezerwacji
 
startPracy = 10 :: Int
 
koniecPracy = 24 :: Int
 

 

 

 
-- uruchomienie programu
 
main = do
 
        sprawdzIUtworzPlikStoliki
 
        sprawdzIUtworzPlikRezerwacje
 
        menuLoop
 

 
-- sprawdza i tworzy nowe pliki jesli nie istnieja
 
sprawdzIUtworzPlikStoliki = do
 
        catch   (do 
 
                putStrLn ("Sprawdzanie " ++ stolikiNazwaPliku)
 
                plik <- readFile stolikiNazwaPliku
 
                return ()
 
                ) errorHandler
 
        where errorHandler e = 
 
                if isDoesNotExistError e then do
 
                        putStrLn ("Tworzenie pliku: " ++ stolikiNazwaPliku)
 
                        writeFile stolikiNazwaPliku (show ([] :: [Stolik]))
 
                        else 
 
                        putStrLn ("Blad przy otwieraniu pliku: " ++ stolikiNazwaPliku)
 

 
                        
 
sprawdzIUtworzPlikRezerwacje = do
 
        catch   (do 
 
                putStrLn ("Sprawdzanie " ++ rezerwacjeNazwaPliku)
 
                plik <- readFile rezerwacjeNazwaPliku
 
                return ()
 
                ) errorHandler
 
        where errorHandler e = 
 
                if isDoesNotExistError e then do
 
                        putStrLn ("Tworzenie pliku: " ++ rezerwacjeNazwaPliku)
 
                        writeFile rezerwacjeNazwaPliku (show ([] :: [Rezerwacja]))
 
                        else 
 
                        putStrLn ("Blad przy otwieraniu pliku: " ++ rezerwacjeNazwaPliku)
 

 
-- Menu glowne - pokazuje ogolne opcje programu.
 
menuLoop :: IO()
 
menuLoop = do 
 
        putStrLn "====================================="
 
        putStrLn "======= R E S T A U R A C J A ======="
 
        putStrLn "====================================="
 
        putStrLn "Menu glowne"
 
        putStrLn "1  Zarzadzanie stolikami"
 
        putStrLn "2  Zarzadzanie rezerwacjami"
 
        putStrLn "3  Wyszukiwanie"
 
        putStrLn "0  Wyjscie"
 
        cmd <- getLine
 
        case cmd of
 
                "1" -> do zarzadzanieStolikami
 
                "2" -> do zarzadzanieRezerwacjami
 
                "3" -> do wyszukiwanie
 
                "0" -> do putStrLn "Koniec."
 
                _ -> do
 
                        putStrLn "Nieprawidlowy nr opcji"
 
                        menuLoop
 

 
-- menu zarzadzania stolikami
 
zarzadzanieStolikami = do
 
        putStrLn "====================================="
 
        putStrLn "Zarzadzanie stolikami"
 
        putStrLn "1  Wyswietl stoliki"
 
        putStrLn "2  Dodaj stolik"
 
        putStrLn "3  Edytuj stolik"
 
        putStrLn "4  Usun stolik"
 
        putStrLn "0  Wroc do menu glownego"
 
        cmd <- getLine
 
        case cmd of
 
                "1" -> do
 
                        wyswietlStoliki
 
                        zarzadzanieStolikami 
 
                "2" -> do
 
                        dodajStolik
 
                        zarzadzanieStolikami 
 
                "3" -> do
 
                        edytujStolik
 
                        zarzadzanieStolikami 
 
                "4" -> do
 
                        usunStolik
 
                        zarzadzanieStolikami 
 
                "0" -> do 
 
                        menuLoop
 
                _ -> do
 
                        putStrLn "Nieprawidlowy nr opcji"
 
                        zarzadzanieStolikami 
 

 
-- wyswietlenie wszystkich stolikow
 
wyswietlStoliki = do
 
        putStrLn "====================================="
 
        stoliki <- wczytajStoliki
 
        putStrLn (stoliki2String stoliki)
 
        putStrLn "====================================="
 

 
-- akcja do dodawania stolika
 
dodajStolik = do
 
        putStrLn "====================================="
 
        putStrLn "Dodawanie stolika"
 
        putStr "Podaj liczbe miejsc: "
 
        liczbaMiejscStr <- getLine
 
        stareStoliki <- wczytajStoliki
 
        if sprawdzCzyToLiczba liczbaMiejscStr == True 
 
                then do
 
                        let 
 
                                stolikId = getNastStolikID stareStoliki 1
 
                                liczbaMiejsc = read liczbaMiejscStr :: Int
 
                                stolik = Stolik stolikId liczbaMiejsc
 
                        zapiszStoliki (stareStoliki ++ [stolik])
 
                        putStrLn "Zapisano stoliki."
 
                else
 
                        putStrLn "Podano zla liczbe."
 

 
-- akcja edycji stolika
 
edytujStolik = do
 
        putStrLn "====================================="
 
        putStrLn "Edycja stolika"
 
        stareStoliki <- wczytajStoliki
 
        putStrLn "Stoliki:"
 
        putStrLn (stoliki2String stareStoliki)
 
        putStr "Podaj ID stolika: "
 
        stolikIdStr <- getLine
 
        if sprawdzCzyToLiczba stolikIdStr then do
 
                let stolikId = (read stolikIdStr) :: Int
 
                let stoliki = znajdzStolikID stareStoliki stolikId
 
                if stoliki /= [] then do
 
                        let stolik = stoliki !! 0
 
                        putStrLn "Znaleziono stolik:" 
 
                        putStrLn (stolik2String stolik)
 
                        putStr "Podaj nowa liczbe miejsc: "
 
                        liczbaMiejscStr <- getLine
 
                        if sprawdzCzyToLiczba liczbaMiejscStr then do
 
                                let liczbaMiejsc = (read liczbaMiejscStr) :: Int
 
                                let nowyStolik = Stolik{stolikId = stolikId, liczbaMiejsc = liczbaMiejsc}
 
                                zapiszStoliki (zastapStolik stareStoliki nowyStolik)
 
                                putStrLn "Zapisano stoliki." 
 
                                else do
 
                                putStrLn "To nie jest liczba."
 
                        else do
 
                        putStrLn "Nie znaleziono stolika o podanym ID."
 
                else do 
 
                putStrLn "To nie jest liczba"
 

 
-- usuniecie stolika
 
usunStolik = do
 
        putStrLn "====================================="
 
        putStrLn "Usuwanie stolika"
 
        stareStoliki <- wczytajStoliki
 
        putStrLn "Stoliki:"
 
        putStrLn (stoliki2String stareStoliki)
 
        putStr "Podaj ID stolika: "
 
        stolikIdStr <- getLine
 
        if sprawdzCzyToLiczba stolikIdStr then do
 
                let stolikId = (read stolikIdStr) :: Int
 
                let stoliki = znajdzStolikID stareStoliki stolikId
 
                if stoliki /= [] then do
 
                        let stolik = stoliki !! 0
 
                        putStrLn "Znaleziono stolik:" 
 
                        putStrLn (stolik2String stolik)
 
                        putStrLn "Czy na pewno chcesz usunac ten stolik? [T/N]"
 
                        potwierdzenie <- getLine
 
                        case (map toLower potwierdzenie) of
 
                                "t" -> do
 
                                        zapiszStoliki (usunStolikZListy stareStoliki stolikId)
 
                                        putStrLn "Stolik usunieto."
 
                                _ -> do
 
                                        putStrLn "Anulowano"
 
                        else do
 
                        putStrLn "Nie znaleziono stolika o podanym ID."
 
                else do 
 
                putStrLn "To nie jest liczba"
 

 
-- menu zarzadzania rezerwacjami
 
zarzadzanieRezerwacjami = do 
 
        putStrLn "Zarzadzanie rezerwacjami"
 
        putStrLn "1 - Dodanie rezerwacji"
 
        putStrLn "2 - Modifykacja rezerwacji"
 
        putStrLn "3 - Usuniecie rezerwacji"
 
        putStrLn "4 - Lista wszystkich rezerwacji"
 
        putStrLn "0 - Powrot do glownego menu"
 
        putStrLn "\nWybierz opcje : "
 
        cmd <- getLine
 
        case cmd of
 
                "1" -> do
 
                        dodajRezerwacje
 
                "2" -> do
 
                        modyfikujRezerwacje
 
                "3" -> do
 
                        usuwanieRezerwacji
 
                "4" -> do
 
                        wszystkieRezerwacje
 
                "0" -> do 
 
                        menuLoop
 
                _ -> do
 
                        putStrLn "Nieprawidlowy nr opcji"
 
                        zarzadzanieRezerwacjami
 

 
-- wyswietl wszystkie rezerwacje
 
wszystkieRezerwacje = do
 
        putStrLn "====================================="
 
        rezerwacje <- wczytajRezerwacje
 
        wypiszRezerwacje rezerwacje
 
        putStrLn "====================================="
 
        zarzadzanieRezerwacjami
 

 

 

 
-- dodaj nowa rezerwacje do bazy danych i zapisz
 
dodajRezerwacje = do
 
        plikStoliki <- readFile stolikiNazwaPliku
 
        plikRezerwacje <- readFile rezerwacjeNazwaPliku
 
        let
 
                stolikiDB = (read plikStoliki) :: [Stolik]
 
                rezerwacjeDB = (read plikRezerwacje) :: [Rezerwacja]
 
        putStrLn "Rezerwacja stolika"
 
        putStr "Podaj dzien rezerwacji (YYYY-MM-DD): "
 
        dataRezerwacjiStr <- getLine
 
        if sprawdzDate dataRezerwacjiStr then do
 
                let dataRezerwacji = (readTime defaultTimeLocale "%F" dataRezerwacjiStr) :: Day
 
                putStr "Podaj godzine rezerwacji: "
 
                godzinaRezerwacjiStr <- getLine
 
                putStr "Podaj dlugosc rezerwacji: "
 
                dlugoscRezerwacjiStr <- getLine
 
                if sprawdzCzyToLiczba godzinaRezerwacjiStr && sprawdzCzyToLiczba dlugoscRezerwacjiStr then do
 
                        let godzinaRezerwacji = (read godzinaRezerwacjiStr ) :: Int
 
                        let dlugoscRezerwacji = (read dlugoscRezerwacjiStr ) :: Int
 
                        if godzinaRezerwacji < koniecPracy && godzinaRezerwacji >= startPracy &&  godzinaRezerwacji + dlugoscRezerwacji <= koniecPracy then do
 
                                -- wyswietlic tylko wolne stoliki 
 
                                let wolneStoliki = znajdzWolneStoliki stolikiDB rezerwacjeDB dataRezerwacji godzinaRezerwacji dlugoscRezerwacji
 
                                putStrLn "\nWolne stoliki o podanej porze:"
 
                                putStrLn (stoliki2String wolneStoliki)
 
                                putStr "Podaj ID stolika: "
 
                                stolikID <- getLine
 
                                putStr "Podaj uwagi: "
 
                                uwagi <- getLine
 
                                putStr "Podaj imie klienta: "
 
                                klientImie <- getLine
 
                                putStr "Podaj nazwisko klienta: "
 
                                klientNazwisko <- getLine
 
                                putStr "Podaj numer telefonu klienta 9 znakow - xxxxxxxxx: "
 
                                klientNrTel <- getLine
 
                                if sprawdzCzyToLiczba klientNrTel == True && length klientNrTel == 9 then do
 
                                        if sprawdzCzyToLiczba stolikID then do
 
                                                let stolik = znajdzStolikID stolikiDB (read stolikID :: Int)
 
                                                putStrLn (stoliki2String stolik)
 
                                                if stolik/=[] then do
 
                                                        let newRezerwacja = Rezerwacja{
 
                                                                rezerwacjaId=getNastRezerID rezerwacjeDB 1,
 
                                                                fkstolikId = (read stolikID :: Int),
 
                                                                imie=klientImie,
 
                                                                nazwisko=klientNazwisko,
 
                                                                numerTel=klientNrTel,
 
                                                                dataRezerwacji = dataRezerwacji,
 
                                                                godzinaRezerwacji = godzinaRezerwacji,
 
                                                                dlugoscRezerwacji = dlugoscRezerwacji,
 
                                                                uwagi = uwagi
 
                                                                }
 
                                                        zapiszRezerwacje (rezerwacjeDB ++ [newRezerwacja])
 
                                                        putStrLn "\nRezerwacja zapisana.\n"
 
                                                        else
 
                                                        putStrLn "\nNie znaleziono stolika o podanym ID!!!!!!!!!!!!!!\n"
 
                                                else
 
                                                putStrLn "\nStolik ID musi byc liczba!!!!!!!!!!!!!!\n"
 
                                        else 
 
                                        putStrLn "\nPodano zly format numeru telefonu!!!!!!!!!!!!!\n"
 
                                else
 
                                putStr ("\nNiepoprawna godzina rezerwacji, wybierz pore zakresu od " ++ show startPracy ++ " do " ++ show koniecPracy ++ " !!!!!!!!!!!!!\n")
 
                        else
 
                        putStr "\nNiepoprawna godzina/dlugosc rezerwacji!!!!!!!!!!!!!!!!!!!!!!\n"
 
                else 
 
                putStrLn "\nData jest nieprawidlowa !!!!!!!!!!!!!!\n"
 
        zarzadzanieRezerwacjami
 

 
-- usun rezerwacje o podanym ID z listy
 
usuwanieRezerwacjiDB :: [Rezerwacja] -> Int -> [Rezerwacja]
 
usuwanieRezerwacjiDB [] _ = []
 
usuwanieRezerwacjiDB (x:xs) id =
 
        if getRezerwacjaID x == id then
 
                xs
 
        else
 
                x : usuwanieRezerwacjiDB xs id
 

 
-- modyfikuj rezerwacje i zapisz do pliku
 
modyfikujRezerwacje = do
 
        putStrLn "Modyfikacja rezerwacji"
 
        plikStoliki <- readFile stolikiNazwaPliku
 
        plikRezerwacje <- readFile rezerwacjeNazwaPliku
 
        let
 
                stolikiDB = (read plikStoliki) :: [Stolik]
 
                rezerwacjeDB = (read plikRezerwacje) :: [Rezerwacja]
 
        wypiszRezerwacje rezerwacjeDB
 
        putStr "Podaj ID rezerwacji: "
 
        rezID <- getLine
 
        putStr "Podaj nowy dzien rezerwacji (YYYY-MM-DD): "
 
        dataRezerwacjiStr <- getLine
 
        if sprawdzDate dataRezerwacjiStr then do
 
                let dataRezerwacji = (readTime defaultTimeLocale "%F" dataRezerwacjiStr) :: Day
 
                putStr "Podaj godzine rezerwacji: "
 
                godzinaRezerwacjiStr <- getLine
 
                putStr "Podaj dlugosc rezerwacji: "
 
                dlugoscRezerwacjiStr <- getLine
 
                if sprawdzCzyToLiczba godzinaRezerwacjiStr && sprawdzCzyToLiczba dlugoscRezerwacjiStr then do
 
                        let godzinaRezerwacji = (read godzinaRezerwacjiStr ) :: Int
 
                        let dlugoscRezerwacji = (read dlugoscRezerwacjiStr ) :: Int
 
                        if godzinaRezerwacji < koniecPracy && godzinaRezerwacji >= startPracy &&  godzinaRezerwacji + dlugoscRezerwacji <= koniecPracy then do
 
                                -- wyswietlic tylko wolne stoliki 
 
                                let wolneStoliki = znajdzWolneStoliki stolikiDB rezerwacjeDB dataRezerwacji godzinaRezerwacji dlugoscRezerwacji
 
                                putStrLn "\nWolne stoliki o podanej porze:"
 
                                putStrLn (stoliki2String wolneStoliki)
 
                                putStr "Podaj ID stolika: "
 
                                stolikID <- getLine
 
                                putStr "Podaj uwagi: "
 
                                uwagi <- getLine
 
                                putStr "Podaj imie klienta: "
 
                                klientImie <- getLine
 
                                putStr "Podaj nazwisko klienta: "
 
                                klientNazwisko <- getLine
 
                                putStr "Podaj numer telefonu klienta 9 znakow - xxxxxxxxx: "
 
                                klientNrTel <- getLine
 
                                if (sprawdzCzyToLiczba klientNrTel == True && length klientNrTel == 9 ) then do
 
                                        if (sprawdzCzyToLiczba stolikID == True) then do
 
                                                let stolik = znajdzStolikID stolikiDB (read stolikID :: Int)
 
                                                putStrLn (stoliki2String stolik)
 
                                                if stolik/=[] then do
 
                                                        let newRezerwacja = Rezerwacja{
 
                                                                rezerwacjaId=(read rezID :: Int),
 
                                                                fkstolikId = (read stolikID :: Int),
 
                                                                imie=klientImie,
 
                                                                nazwisko=klientNazwisko,
 
                                                                numerTel=klientNrTel,
 
                                                                dataRezerwacji = dataRezerwacji,
 
                                                                godzinaRezerwacji = godzinaRezerwacji,
 
                                                                dlugoscRezerwacji = dlugoscRezerwacji,
 
                                                                uwagi = uwagi
 
                                                                }
 
                                                        let newRezerwacjeDB = usuwanieRezerwacjiDB rezerwacjeDB (read rezID :: Int)
 
                                                        zapiszRezerwacje (newRezerwacjeDB ++ [newRezerwacja])
 
                                                        putStrLn "\nRezerwacja zostala zmieniana.\n"
 
                                                        else
 
                                                        putStrLn "\nNie znaleziono stolika o podanym ID!!!!!!!!!!!!!!\n"
 
                                                else
 
                                                putStrLn "\nStolik ID musi byc liczba!!!!!!!!!!!!!!\n"
 
                                        else
 
                                        putStrLn "\nPodano zly format numeru telefonu!!!!!!!!!!!!!\n"
 
                                else
 
                                putStr ("\nNiepoprawna godzina rezerwacji, wybierz pore zakresu od " ++ show startPracy ++ " do " ++ show koniecPracy ++ " !!!!!!!!!!!!!\n")
 
                        else
 
                        putStr "\nNiepoprawna godzina/dlugosc rezerwacji!!!!!!!!!!!!!!!!!!!!!!\n"
 
                else 
 
                putStrLn "\nData jest nieprawidlowa !!!!!!!!!!!!!!\n"
 
        zarzadzanieRezerwacjami
 
        
 
        
 
-- usun rezerwacje i zapisz do pliku        
 
usuwanieRezerwacji = do
 
        plikRezerwacje <- readFile rezerwacjeNazwaPliku
 
        let
 
                rezerwacjeDB = (read plikRezerwacje) :: [Rezerwacja]
 
        wypiszRezerwacje rezerwacjeDB
 
        putStr "Podaj ID rezerwacji do usuniecia: "
 
        rezID <- getLine
 
        let
 
                rezerwacja = znajdzRezerwacjeID rezerwacjeDB (read rezID :: Int)
 
        if sprawdzCzyToLiczba rezID == True && rezerwacja/=[]
 
                then do
 
                        let
 
                                newRezerwacjeDB = usuwanieRezerwacjiDB rezerwacjeDB (read rezID :: Int)
 
                        zapiszRezerwacje newRezerwacjeDB
 
                        putStrLn "\nRezerwacja usunieta.\n"
 
                else
 
                        putStrLn "\n!!!!!!!!!!!Podano zly numer!!!!!!!!!!!\n"
 
        zarzadzanieRezerwacjami
 

 
-- menu wyszukiwania
 
wyszukiwanie = do
 
        putStrLn "Wyszukiwanie"
 
        putStrLn "1 - Wyszukanie rezerwacji po nazwisku"
 
        putStrLn "2 - Wyszukanie wolnych stolikow po dacie"
 
        putStrLn "0 - Powrot"
 
        putStr "\nWybierz opcje : "
 
        cmd <- getLine
 
        case cmd of
 
                "1" -> do
 
                        wyszukajPoNazwisku
 
                "2" -> do
 
                        wyszukajPoDacie
 
                "0" -> do 
 
                        menuLoop
 
                _ -> do
 
                        putStrLn "Nieprawidlowy nr opcji"
 
                        wyszukiwanie
 
        
 
-- wyszukiwanie rezerwacji wg nazwiska
 
wyszukajPoNazwisku = do
 
        putStrLn "Wyszukiwanie po nazwisku"
 
        putStrLn "Wpisz nazwisko: "
 
        nazwisko <- getLine
 
        plikRezerwacje <- readFile rezerwacjeNazwaPliku
 
        plikStoliki <- readFile stolikiNazwaPliku
 
        let
 
                rezerwacjeDB = (read plikRezerwacje) :: [Rezerwacja]
 
                znaleziono = szukajRezerwacjiPoNazwisku rezerwacjeDB nazwisko
 
                stolikiDB = (read plikStoliki) :: [Stolik]
 
        putStrLn "Wynik wyszukiwania:"
 
        if( length znaleziono > 0 )
 
                then do
 
                        putStrLn (rezerwacje2String znaleziono stolikiDB)
 
                else
 
                        putStrLn "\n!!!!!!!!!!!!!!! Brak wynikow dla podanego nazwiska !!!!!!!!!!!!!!\n"
 
        wyszukiwanie
 

 

 
        
 
-- Funkcja wyszukujaca rezerwacji, po podanym nazwisku.
 
szukajRezerwacjiPoNazwisku :: [Rezerwacja] -> String -> [Rezerwacja]
 
szukajRezerwacjiPoNazwisku [] _ = []
 
szukajRezerwacjiPoNazwisku (x:xs) key = 
 
        if (isInfixOf (stringToLower key) (stringToLower (podajNazwisko x))) 
 
                then
 
                        x : szukajRezerwacjiPoNazwisku xs key
 
                else
 
                        szukajRezerwacjiPoNazwisku xs key
 

 

 
-- wyszukiwanie wolnych stolikow wg daty i godziny rezerwacji
 
wyszukajPoDacie = do
 
        putStrLn "Wyszukiwanie wolnych stolikow wg daty"
 
        plikStoliki <- readFile stolikiNazwaPliku
 
        plikRezerwacje <- readFile rezerwacjeNazwaPliku
 
        let
 
                stolikiDB = (read plikStoliki) :: [Stolik]
 
                rezerwacjeDB = (read plikRezerwacje) :: [Rezerwacja]
 
        putStr "Podaj dzien rezerwacji (YYYY-MM-DD): "
 
        startD <- getLine
 
        if (sprawdzDate startD == True) then do
 
                putStr "Podaj godzine rezerwacji: "
 
                startG <- getLine
 
                putStr "Podaj dlugosc rezerwacji: "
 
                dlugoscRezerwacji <- getLine
 
                if( sprawdzCzyToLiczba startG && sprawdzCzyToLiczba dlugoscRezerwacji ) then do
 
                        let
 
                                dataRezerwacji = (readTime defaultTimeLocale "%F" startD) :: Day
 
                                znalezioneStoliki = znajdzWolneStoliki stolikiDB rezerwacjeDB dataRezerwacji (read startG :: Int) (read dlugoscRezerwacji :: Int)
 
                        putStrLn "Wolne stoliki w podanym dniu o podanej porze:"
 
                        putStrLn (stoliki2String znalezioneStoliki)
 
                        else
 
                        putStrLn "\n!!!!!!!!!!!!!!!Podano nieporpawna godzine lub dlugosc rezerwacji !!!!!!!!!!!!!!\n"
 
                else
 
                putStrLn "\n!!!!!!!!!!!!!!!Podany zla  date!!!!!!!!!!!!!!\n"
 
        wyszukiwanie
 
